home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2005 October / PCWOCT05.iso / Software / FromTheMag / XAMPP 1.4.14 / xampp-win32-1.4.14-installer.exe / xampp / php / pear / Math / IntegerOp.php < prev    next >
PHP Script  |  2004-03-24  |  14KB  |  405 lines
  1. <?php
  2. //
  3. // +----------------------------------------------------------------------+
  4. // | PHP Version 4                                                        |
  5. // +----------------------------------------------------------------------+
  6. // | Copyright (c) 1997-2002 The PHP Group                                |
  7. // +----------------------------------------------------------------------+
  8. // | This source file is subject to version 2.0 of the PHP license,       |
  9. // | that is bundled with this package in the file LICENSE, and is        |
  10. // | available at through the world-wide-web at                           |
  11. // | http://www.php.net/license/2_02.txt.                                 |
  12. // | If you did not receive a copy of the PHP license and are unable to   |
  13. // | obtain it through the world-wide-web, please send a note to          |
  14. // | license@php.net so we can mail you a copy immediately.               |
  15. // +----------------------------------------------------------------------+
  16. // | Authors: Jesus M. Castagnetto <jmcastagnetto@php.net>                |
  17. // +----------------------------------------------------------------------+
  18. //
  19. // $Id: IntegerOp.php,v 1.1 2003/01/02 01:55:05 jmcastagnetto Exp $
  20. //
  21.  
  22. include_once 'Math/Integer.php';
  23.  
  24. /**
  25.  * Class implementing operations on Math_Integer objects. If available it
  26.  * will use the GMP or BCMATH libraries. Will default to the standard PHP
  27.  * integer representation otherwise.
  28.  * 
  29.  * The operations are implemented as static methods of the class.
  30.  *
  31.  * @author  Jesus M. Castagnetto <jmcastagnetto@php.net>
  32.  * @version 0.8
  33.  * @access  public
  34.  * @package Math_Integer
  35.  */
  36. class Math_IntegerOp {/*{{{*/
  37.  
  38.     /**
  39.      * Checks if the given parameter is a Math_Integer object
  40.      *
  41.      * @param object Math_Integer $int1
  42.      * @return boolean TRUE if parameter is an instance of Math_Integer, FALSE otherwise
  43.      * @access public
  44.      */
  45.     function isMath_Integer(&$int) {/*{{{*/
  46.         if (function_exists('is_a')) {
  47.             return is_a($int, 'Math_Integer');
  48.         } else {
  49.             return get_class($int) == 'math_integer' 
  50.                     || is_subclass_of($int, 'math_integer');
  51.         }
  52.     }/*}}}*/
  53.  
  54.     /**
  55.      * Add two Math_Integer objects: $i1 + $i2
  56.      *
  57.      * @param object Math_Integer $int1
  58.      * @param object Math_Integer $int2
  59.      * @return object Math_Integer on success, PEAR_Error otherwise
  60.      * @access public
  61.      */
  62.     function &add(&$int1, &$int2) {/*{{{*/
  63.         if (PEAR::isError($err = Math_IntegerOp::_validInts($int1, $int2))) {
  64.             return $err;
  65.         }
  66.         switch (MATH_INTLIB) {/*{{{*/
  67.             case 'gmp' :
  68.                 $tmp = gmp_strval(gmp_add($int1->getValue(), $int2->getValue()));
  69.                 break;
  70.             case 'bcmath' :
  71.                 $tmp = bcadd($int1->getValue(), $int2->getValue());
  72.                 break;
  73.             case 'std' :
  74.                 $tmp = $int1->getValue() + $int2->getValue(); 
  75.                 break;
  76.         }/*}}}*/
  77.         return new Math_Integer($tmp);
  78.     }/*}}}*/
  79.  
  80.     /**
  81.      * Substract two Math_Integer objects: $i1 - $i2
  82.      *
  83.      * @param object Math_Integer $int1
  84.      * @param object Math_Integer $int2
  85.      * @return object Math_Integer on success, PEAR_Error otherwise
  86.      * @access public
  87.      */
  88.     function &sub(&$int1, &$int2) {/*{{{*/
  89.         if (PEAR::isError($err = Math_IntegerOp::_validInts($int1, $int2))) {
  90.             return $err;
  91.         }
  92.         switch (MATH_INTLIB) {/*{{{*/
  93.             case 'gmp' :
  94.                 $tmp = gmp_strval(gmp_sub($int1->getValue(), $int2->getValue()));
  95.                 break;
  96.             case 'bcmath' :
  97.                 $tmp = bcsub($int1->getValue(), $int2->getValue());
  98.                 break;
  99.             case 'std' :
  100.                 $tmp = $int1->getValue() - $int2->getValue(); 
  101.                 break;
  102.         }/*}}}*/
  103.         return new Math_Integer($tmp);
  104.     }/*}}}*/
  105.  
  106.     /**
  107.      * Multiply two Math_Integer objects: $i1 * $i2
  108.      *
  109.      * @param object Math_Integer $int1
  110.      * @param object Math_Integer $int2
  111.      * @return object Math_Integer on success, PEAR_Error otherwise
  112.      * @access public
  113.      */
  114.     function &mul(&$int1, &$int2) {/*{{{*/
  115.         if (PEAR::isError($err = Math_IntegerOp::_validInts($int1, $int2))) {
  116.             return $err;
  117.         }
  118.         switch (MATH_INTLIB) {/*{{{*/
  119.             case 'gmp' :
  120.                 $tmp = gmp_strval(gmp_mul($int1->getValue(), $int2->getValue()));
  121.                 break;
  122.             case 'bcmath' :
  123.                 $tmp = bcmul($int1->getValue(), $int2->getValue());
  124.                 break;
  125.             case 'std' :
  126.                 $tmp = $int1->getValue() * $int2->getValue(); 
  127.                 break;
  128.         }/*}}}*/
  129.         return new Math_Integer($tmp);
  130.     }/*}}}*/
  131.  
  132.     /**
  133.      * Divide two Math_Integer objects: $i1 / $i2
  134.      *
  135.      * @param object Math_Integer $int1
  136.      * @param object Math_Integer $int2
  137.      * @return object Math_Integer on success, PEAR_Error otherwise
  138.      * @access public
  139.      */
  140.     function &div(&$int1, &$int2) {/*{{{*/
  141.         if (PEAR::isError($err = Math_IntegerOp::_validInts($int1, $int2))) {
  142.             return $err;
  143.         }
  144.         switch (MATH_INTLIB) {/*{{{*/
  145.             case 'gmp' :
  146.                 $tmp = gmp_strval(gmp_div($int1->getValue(), $int2->getValue()));
  147.                 break;
  148.             case 'bcmath' :
  149.                 $tmp = bcdiv($int1->getValue(), $int2->getValue());
  150.                 break;
  151.             case 'std' :
  152.                 $tmp = intval($int1->getValue() / $int2->getValue()); 
  153.                 break;
  154.         }/*}}}*/
  155.         return new Math_Integer($tmp);
  156.     }/*}}}*/
  157.  
  158.     /**
  159.      * Calculate the modulus of $i1 and $i2: $i1 % $i2
  160.      *
  161.      * @param object Math_Integer $int1
  162.      * @param object Math_Integer $int2
  163.      * @return object Math_Integer on success, PEAR_Error otherwise
  164.      * @access public
  165.      */
  166.     function &mod(&$int1, &$int2) {/*{{{*/
  167.         if (PEAR::isError($err = Math_IntegerOp::_validInts($int1, $int2))) {
  168.             return $err;
  169.         }
  170.         switch (MATH_INTLIB) {/*{{{*/
  171.             case 'gmp' :
  172.                 $tmp = gmp_strval(gmp_mod($int1->getValue(), $int2->getValue()));
  173.                 break;
  174.             case 'bcmath' :
  175.                 $tmp = bcmod($int1->getValue(), $int2->getValue());
  176.                 break;
  177.             case 'std' :
  178.                 $tmp = $int1->getValue() % $int2->getValue(); 
  179.                 break;
  180.         }/*}}}*/
  181.         return new Math_Integer($tmp);
  182.     }/*}}}*/
  183.  
  184.     /**
  185.      * Raise $i1 to the $i2 exponent: $i1^$i2
  186.      *
  187.      * @param object Math_Integer $int1
  188.      * @param object Math_Integer $int2
  189.      * @return object Math_Integer on success, PEAR_Error otherwise
  190.      * @access public
  191.      */
  192.     function &pow(&$int1, &$int2) {/*{{{*/
  193.         if (PEAR::isError($err = Math_IntegerOp::_validInts($int1, $int2))) {
  194.             return $err;
  195.         }
  196.         switch (MATH_INTLIB) {/*{{{*/
  197.             case 'gmp' :
  198.                 $tmp = gmp_strval(gmp_pow($int1->getValue(), (int) $int2->toString()));
  199.                 break;
  200.             case 'bcmath' :
  201.                 $tmp = bcpow($int1->getValue(), $int2->getValue());
  202.                 break;
  203.             case 'std' :
  204.                 $tmp = pow($int1->getValue(), $int2->getValue()); 
  205.                 break;
  206.         }/*}}}*/
  207.         return new Math_Integer($tmp);
  208.     }/*}}}*/
  209.  
  210.     /**
  211.      * Compare two Math_Integer objects.
  212.      * if $i1 > $i2, returns +1,
  213.      * if $i1 == $i2, returns +0,
  214.      * if $i1 < $i2, returns -1,
  215.      *
  216.      * @param object Math_Integer $int1
  217.      * @param object Math_Integer $int2
  218.      * @return mixed and integer on success, PEAR_Error otherwise
  219.      * @access public
  220.      * @see Math_IntegerOp::sign
  221.      */
  222.     function &compare(&$int1, &$int2) {/*{{{*/
  223.         if (PEAR::isError($err = Math_IntegerOp::_validInts($int1, $int2))) {
  224.             return $err;
  225.         }
  226.         switch (MATH_INTLIB) {/*{{{*/
  227.             case 'gmp' :
  228.                 $cmp = gmp_cmp($int1->getValue(), $int2->getValue());
  229.                 break;
  230.             case 'bcmath' :
  231.                 $cmp = bccomp($int1->getValue(), $int2->getValue());
  232.                 break;
  233.             case 'std' :
  234.                 $cmp = $int1->getValue() - $int2->getValue(); 
  235.                 break;
  236.         }/*}}}*/
  237.         return Math_IntegerOp::sign(new Math_Integer($cmp));
  238.     }/*}}}*/
  239.  
  240.     /**
  241.      * Returns the sign of a Math_Integer number
  242.      * if $i1 > 0, returns +1,
  243.      * if $i1 == 0, returns +0,
  244.      * if $i1 < 0, returns -1,
  245.      *
  246.      * @param object Math_Integer $int1
  247.      * @return mixed and integer on success, PEAR_Error otherwise
  248.      * @access public
  249.      */
  250.     function &sign(&$int1) {/*{{{*/
  251.         if (PEAR::isError($err = Math_IntegerOp::_validInt($int1))) {
  252.             return $err;
  253.         }
  254.         switch (MATH_INTLIB) {/*{{{*/
  255.             case 'gmp' :
  256.                 return gmp_sign($int1->getValue());
  257.                 break;
  258.             case 'bcmath' :
  259.             case 'std' :
  260.                 $tmp = $int1->getValue();
  261.                 if ($tmp > 0) {
  262.                     return 1;
  263.                 } elseif ($tmp < 0) {
  264.                     return -1;
  265.                 } else { // $tmp == 0
  266.                     return 0;
  267.                 }
  268.                 break;
  269.         }/*}}}*/
  270.     }/*}}}*/
  271.  
  272.     /**
  273.      * Returns the negative of a Math_Integer number: -1 * $i1
  274.      *
  275.      * @param object Math_Integer $int1
  276.      * @return object Math_Integer on success, PEAR_Error otherwise
  277.      * @access public
  278.      */
  279.     function &neg(&$int1) {/*{{{*/
  280.         if (PEAR::isError($err = Math_IntegerOp::_validInt($int1))) {
  281.             return $err;
  282.         }
  283.         switch (MATH_INTLIB) {/*{{{*/
  284.             case 'gmp' :
  285.                 $tmp = gmp_strval(gmp_neg($int1->getValue()));
  286.                 break;
  287.             case 'bcmath' :
  288.                 $tmp = bcmul(-1, $int1->getValue());
  289.                 break;
  290.             case 'std' :
  291.                 $tmp = -1 * $int1->getValue();
  292.                 break;
  293.         }/*}}}*/
  294.         return new Math_Integer($tmp);
  295.     }/*}}}*/
  296.  
  297.     /**
  298.      * Returns the (integer) square root of a Math_Integer number
  299.      *
  300.      * @param object Math_Integer $int1
  301.      * @return object Math_Integer on success, PEAR_Error otherwise
  302.      * @access public
  303.      */
  304.     function &sqrt(&$int1) {/*{{{*/
  305.         if (PEAR::isError($err = Math_IntegerOp::_validInt($int1))) {
  306.             return $err;
  307.         }
  308.         switch (MATH_INTLIB) {/*{{{*/
  309.             case 'gmp' :
  310.                 $tmp = gmp_strval(gmp_sqrt($int1->getValue()));
  311.                 break;
  312.             case 'bcmath' :
  313.                 $tmp = bcsqrt(-1, $int1->getValue());
  314.                 break;
  315.             case 'std' :
  316.                 $tmp = intval(sqrt($int1->getValue()));
  317.                 break;
  318.         }/*}}}*/
  319.         return new Math_Integer($tmp);
  320.     }/*}}}*/
  321.  
  322.     /**
  323.      * Returns the absolute value of a Math_Integer number
  324.      *
  325.      * @param object Math_Integer $int1
  326.      * @return object Math_Integer on success, PEAR_Error otherwise
  327.      * @access public
  328.      */
  329.     function &abs(&$int1) {/*{{{*/
  330.         if (PEAR::isError($err = Math_IntegerOp::_validInt($int1))) {
  331.             return $err;
  332.         }
  333.         switch (MATH_INTLIB) {/*{{{*/
  334.             case 'gmp' :
  335.                 $tmp = gmp_strval(gmp_abs($int1->getValue()));
  336.                 break;
  337.             case 'bcmath' :
  338.                 if ($int1->getValue() < 0) {
  339.                     $tmp = bcmul(-1, $int1->getValue());
  340.                 } else {
  341.                     $tmp = $int1->getValue();
  342.                 }
  343.                 break;
  344.             case 'std' :
  345.                 $tmp = abs($int1->getValue());
  346.                 break;
  347.         }/*}}}*/
  348.         return new Math_Integer($tmp);
  349.     }/*}}}*/
  350.  
  351.     /**
  352.      * Checks that the 2 passed objects are valid Math_Integer numbers.
  353.      * The objects must be instances of Math_Integer and have been properly
  354.      * initialized.
  355.      *
  356.      * @param object Math_Integer $int1
  357.      * @param object Math_Integer $int2
  358.      * @return mixed TRUE if both are Math_Integer objects, PEAR_Error otherwise
  359.      * @access private
  360.      */
  361.     function _validInts(&$int1, &$int2) {/*{{{*/
  362.         $err1 = Math_IntegerOp::_validInt($int1);
  363.         $err2 = Math_IntegerOp::_validInt($int2);
  364.         $error = '';
  365.         if (PEAR::isError($err1)) {
  366.             $error .= 'First parameter: '.$err1->getMessage();
  367.         }
  368.         if (PEAR::isError($err2)) {
  369.             $error .= ' Second parameter: '.$err2->getMessage();
  370.         }
  371.         if (!empty($error)) {
  372.             return PEAR::raiseError($error);
  373.         } else {
  374.             return true;
  375.         }
  376.     }/*}}}*/
  377.  
  378.     /**
  379.      * Checks that the passed object is a valid Math_Integer number.
  380.      * The object must be an instance of Math_Integer and have been properly
  381.      * initialized.
  382.      *
  383.      * @param object Math_Integer $int1
  384.      * @return mixed TRUE if is a Math_Integer object, PEAR_Error otherwise
  385.      * @access private
  386.      */
  387.     function _validInt(&$int1) {/*{{{*/
  388.         $error = '';
  389.         if (!Math_IntegerOp::isMath_Integer($int1)) {
  390.             $error = 'Is not a Math_Integer object.';
  391.         } elseif (!$int1->initialized()) {
  392.             $error = 'Math_Integer object is uninitalized.';
  393.         }
  394.         if (!empty($error)) {
  395.             return PEAR::raiseError($error);
  396.         } else {
  397.             return true;
  398.         }
  399.     }/*}}}*/
  400. }/*}}} end of Math_IntegerOp */
  401.  
  402. // vim: ts=4:sw=4:et:
  403. // vim6: fdl=1:
  404. ?>
  405.